home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / dnr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  7.4 KB  |  295 lines  |  [TEXT/MPS ]
  1. /*            DNR.c - DNR library for MPW
  2.  
  3.                 (c) Copyright 1988 by Apple Computer.  All rights reserved
  4.                 
  5.                 Modifications by Jim Matthews, Dartmouth College, 5/91
  6.                 
  7. */
  8. #pragma segment DNR
  9.  
  10. #include <OSUtils.h>
  11. #include <Errors.h>
  12. #include <Files.h>
  13. #include <Resources.h>
  14. #include <Memory.h>
  15. #include <Traps.h>
  16. #include <GestaltEqu.h>
  17. #include <Folders.h>
  18. #include <ToolUtils.h>
  19.  
  20. #define OPENRESOLVER        1
  21. #define CLOSERESOLVER     2
  22. #define STRTOADDR                             3
  23. #define ADDRTOSTR                             4
  24. #define ENUMCACHE                             5
  25. #define ADDRTONAME                            6
  26. #define HINFO                                     7
  27. #define MXINFO                                    8
  28.  
  29. Handle codeHndl = nil;
  30.  
  31. typedef OSErr (*OSErrProcPtr)();
  32. OSErrProcPtr dnr = nil;
  33.  
  34.  
  35. TrapType GetTrapType(theTrap)
  36. unsigned long theTrap;
  37. {
  38.                 if (BitAnd(theTrap, 0x0800) > 0)
  39.                                 return(ToolTrap);
  40.                 else
  41.                                 return(OSTrap);
  42.                 }
  43.                 
  44. Boolean TrapAvailable(trap)
  45. unsigned long trap;
  46. {
  47. TrapType trapType = ToolTrap;
  48. unsigned long numToolBoxTraps;
  49.  
  50.                 if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  51.                                 numToolBoxTraps = 0x200;
  52.                 else
  53.                                 numToolBoxTraps = 0x400;
  54.  
  55.                 trapType = GetTrapType(trap);
  56.                 if (trapType == ToolTrap) {
  57.                                 trap = BitAnd(trap, 0x07FF);
  58.                                 if (trap >= numToolBoxTraps)
  59.                                                 trap = _Unimplemented;
  60.                                 }
  61.                 return(NGetTrapAddress(trap, trapType) != NGetTrapAddress(_Unimplemented, ToolTrap));
  62.  
  63. }
  64.  
  65. void GetSystemFolder(short *vRefNumP, long *dirIDP)
  66. {
  67.                 SysEnvRec info;
  68.                 long wdProcID;
  69.                 
  70.                 SysEnvirons(1, &info);
  71.                 if (GetWDInfo(info.sysVRefNum, vRefNumP, dirIDP, &wdProcID) != noErr) {
  72.                                 *vRefNumP = 0;
  73.                                 *dirIDP = 0;
  74.                                 }
  75.                 }
  76.  
  77. void GetCPanelFolder(short *vRefNumP, long *dirIDP)
  78. {
  79.                 Boolean hasFolderMgr = false;
  80.                 long feature;
  81.                 
  82.                 if (Gestalt(gestaltFindFolderAttr, &feature) == noErr) hasFolderMgr = true;
  83.                 if (!hasFolderMgr) {
  84.                                 GetSystemFolder(vRefNumP, dirIDP);
  85.                                 return;
  86.                                 }
  87.                 else {
  88.                                 if (FindFolder(kOnSystemDisk, kControlPanelFolderType, kDontCreateFolder, vRefNumP, dirIDP) != noErr) {
  89.                                                 *vRefNumP = 0;
  90.                                                 *dirIDP = 0;
  91.                                                 }
  92.                                 }
  93.                 }
  94.                 
  95. /* SearchFolderForDNRP is called to search a folder for files that might
  96.                 contain the 'dnrp' resource */
  97. short SearchFolderForDNRP(long targetType, long targetCreator, short vRefNum, long dirID)
  98. {
  99.                 HParamBlockRec fi;
  100.                 Str255 filename;
  101.                 short refnum;
  102.                 
  103.                 fi.fileParam.ioCompletion = nil;
  104.                 fi.fileParam.ioNamePtr = filename;
  105.                 fi.fileParam.ioVRefNum = vRefNum;
  106.                 fi.fileParam.ioDirID = dirID;
  107.                 fi.fileParam.ioFDirIndex = 1;
  108.                 
  109.                 while (PBHGetFInfo(&fi, false) == noErr) {
  110.                                 /* scan system folder for driver resource files of specific type & creator */
  111.                                 if (fi.fileParam.ioFlFndrInfo.fdType == targetType &&
  112.                                                 fi.fileParam.ioFlFndrInfo.fdCreator == targetCreator) {
  113.                                                 /* found the MacTCP driver file? */
  114.                                                 refnum = HOpenResFile(vRefNum, dirID, filename, fsRdPerm);
  115.                                                 if (GetIndResource('dnrp', 1) == NULL)
  116.                                                                 CloseResFile(refnum);
  117.                                                 else
  118.                                                                 return refnum;
  119.                                                 }
  120.                                 /* check next file in system folder */
  121.                                 fi.fileParam.ioFDirIndex++;
  122.                                 fi.fileParam.ioDirID = dirID;     /* PBHGetFInfo() clobbers ioDirID */
  123.                                 }
  124.                 return(-1);
  125.                 }             
  126.  
  127. /* OpenOurRF is called to open the MacTCP driver resources */
  128.  
  129. short OpenOurRF()
  130. {
  131.                 short refnum;
  132.                 short vRefNum;
  133.                 long dirID;
  134.                 
  135.                 /* first search Control Panels for MacTCP 1.1 */
  136.                 GetCPanelFolder(&vRefNum, &dirID);
  137.                 refnum = SearchFolderForDNRP('cdev', 'ztcp', vRefNum, dirID);
  138.                 if (refnum != -1) return(refnum);
  139.                                 
  140.                 /* next search System Folder for MacTCP 1.0.x */
  141.                 GetSystemFolder(&vRefNum, &dirID);
  142.                 refnum = SearchFolderForDNRP('cdev', 'mtcp', vRefNum, dirID);
  143.                 if (refnum != -1) return(refnum);
  144.                                 
  145.                 /* finally, search Control Panels for MacTCP 1.0.x */
  146.                 GetCPanelFolder(&vRefNum, &dirID);
  147.                 refnum = SearchFolderForDNRP('cdev', 'mtcp', vRefNum, dirID);
  148.                 if (refnum != -1) return(refnum);
  149.                                 
  150.                 return -1;
  151.                 }             
  152.  
  153.  
  154. OSErr OpenResolver(fileName)
  155. char *fileName;
  156. {
  157.                 short refnum;
  158.                 OSErr rc;
  159.                 
  160.                 if (dnr != nil)
  161.                                 /* resolver already loaded in */
  162.                                 return(noErr);
  163.                                 
  164.                 /* open the MacTCP driver to get DNR resources. Search for it based on
  165.                      creator & type rather than simply file name */             
  166.                 refnum = OpenOurRF();
  167.  
  168.                 /* ignore failures since the resource may have been installed in the
  169.                      System file if running on a Mac 512Ke */
  170.                     
  171.                 /* load in the DNR resource package */
  172.                 ResrvMem(16000L);             /* s-dorner@uiuc.edu, 9/5/91 */
  173.                 codeHndl = GetIndResource('dnrp', 1);
  174.                 if (codeHndl == nil) {
  175.                                 /* can't open DNR */
  176.                                 return(ResError());
  177.                                 }
  178.                 
  179.                 DetachResource(codeHndl);
  180.                 if (refnum != -1) {
  181.                                 CloseWD(refnum);
  182.                                 CloseResFile(refnum);
  183.                                 }
  184.                                 
  185.                 /* lock the DNR resource since it cannot be reloated while opened */
  186.                 HLock(codeHndl);
  187.                 dnr = (OSErrProcPtr) *codeHndl;
  188.                 
  189.                 /* call open resolver */
  190.                 rc = (*dnr)(OPENRESOLVER, fileName);
  191.                 if (rc != noErr) {
  192.                                 /* problem with open resolver, flush it */
  193.                                 HUnlock(codeHndl);
  194.                                 DisposHandle(codeHndl);
  195.                                 dnr = nil;
  196.                                 }
  197.                 return(rc);
  198.                 }
  199.  
  200.  
  201. OSErr CloseResolver()
  202. {
  203.                 if (dnr == nil)
  204.                                 /* resolver not loaded error */
  205.                                 return(notOpenErr);
  206.                                 
  207.                 /* call close resolver */
  208.                 (void) (*dnr)(CLOSERESOLVER);
  209.  
  210.                 /* release the DNR resource package */
  211.                 HUnlock(codeHndl);
  212.                 DisposHandle(codeHndl);
  213.                 dnr = nil;
  214.                 return(noErr);
  215.                 }
  216.  
  217. OSErr StrToAddr(hostName, rtnStruct, resultproc, userDataPtr)
  218. char *hostName;
  219. struct hostInfo *rtnStruct;
  220. long resultproc;
  221. char *userDataPtr;
  222. {
  223.                 if (dnr == nil)
  224.                                 /* resolver not loaded error */
  225.                                 return(notOpenErr);
  226.                                 
  227.                 return((*dnr)(STRTOADDR, hostName, rtnStruct, resultproc, userDataPtr));
  228.                 }
  229.                 
  230. OSErr AddrToStr(addr, addrStr)
  231. unsigned long addr;
  232. char *addrStr;                                                                                                                                    
  233. {
  234.                 if (dnr == nil)
  235.                                 /* resolver not loaded error */
  236.                                 return(notOpenErr);
  237.                                 
  238.                 (*dnr)(ADDRTOSTR, addr, addrStr);
  239.                 return(noErr);
  240.                 }
  241.                 
  242. OSErr EnumCache(resultproc, userDataPtr)
  243. long resultproc;
  244. char *userDataPtr;
  245. {
  246.                 if (dnr == nil)
  247.                                 /* resolver not loaded error */
  248.                                 return(notOpenErr);
  249.                                 
  250.                 return((*dnr)(ENUMCACHE, resultproc, userDataPtr));
  251.                 }
  252.                 
  253.                 
  254. OSErr AddrToName(addr, rtnStruct, resultproc, userDataPtr)
  255. unsigned long addr;
  256. struct hostInfo *rtnStruct;
  257. long resultproc;
  258. char *userDataPtr;                                                                                                                                            
  259. {
  260.                 if (dnr == nil)
  261.                                 /* resolver not loaded error */
  262.                                 return(notOpenErr);
  263.                                 
  264.                 return((*dnr)(ADDRTONAME, addr, rtnStruct, resultproc, userDataPtr));
  265.                 }
  266.  
  267.  
  268. extern OSErr HInfo(hostName, returnRecPtr, resultProc, userDataPtr)
  269. char *hostName;
  270. struct returnRec *returnRecPtr;
  271. long resultProc;
  272. char *userDataPtr;
  273. {
  274.                 if (dnr == nil)
  275.                                 /* resolver not loaded error */
  276.                                 return(notOpenErr);
  277.                                 
  278.                 return((*dnr)(HINFO, hostName, returnRecPtr, resultProc, userDataPtr));
  279.  
  280.                 }
  281.                 
  282. extern OSErr MXInfo(hostName, returnRecPtr, resultProc, userDataPtr)
  283. char *hostName;
  284. struct returnRec *returnRecPtr;
  285. long resultProc;
  286. char *userDataPtr;
  287. {
  288.                 if (dnr == nil)
  289.                                 /* resolver not loaded error */
  290.                                 return(notOpenErr);
  291.                                 
  292.                 return((*dnr)(MXINFO, hostName, returnRecPtr, resultProc, userDataPtr));
  293.  
  294.                 };
  295.